/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Funcionalidades;

import br.com.beautycenter.DAO.PersisteFuncionario;
import br.com.beautycenter.DAO.PersisteCliente;
import br.com.beautycenter.bean.Funcionario;
import br.com.beautycenter.bean.Cliente;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.util.Date;
import javax.swing.JOptionPane;
import javax.swing.text.MaskFormatter;
import org.joda.time.DateTime;

/**
 *
 * @author magelinha
 */
public class Validacoes {

    
    public static final DecimalFormat formatoMoeda = new DecimalFormat("#,##0.00");
    public static MaskFormatter mascaraCep;
    public static MaskFormatter mascaraCpf;
    public static MaskFormatter mascaraTelefone;
    public static MaskFormatter mascaraHorario;
    
    /**
     * Inicializa todas as mascaras. Isso é necessário por causa do lançamento de exceção
     */
    public static void inicializarMascaras(){
        try {
            mascaraCep = new MaskFormatter("##.###-###"); mascaraCep.setPlaceholder("_");
            mascaraCpf = new MaskFormatter("###.###.###-##"); mascaraCpf.setPlaceholder("_");
            mascaraTelefone = new MaskFormatter("(##)####-####"); mascaraTelefone.setPlaceholder("_");
            mascaraHorario = new MaskFormatter("##:##"); mascaraHorario.setPlaceholder("_");
        } catch (ParseException ex) {
            JOptionPane.showMessageDialog(null, "Erro ao inicializar máscaras");
            ex.printStackTrace();
        }
    }
    
    /**
     * Verifica se contém alguma letra na string.
     * @return 
     * - <b>true</b> - Caso não tenha uma letra na String <br/>
     * - <b>false</b> - Caso tenha uma letra na String <br/>
     */
    public static boolean validarCampoNumerico(String campo){
        for(int i=0; i<campo.length(); i++){
            if(!Character.isDigit(campo.charAt(i))){
                //se chegar aqui é porque tem uma letra
                return false;
            }
        }
        
        return true;
    }
    
    /**
     * Verifica se o valor passado como parâmetro está no formado moeda (123,00)
     * O Retorno é Double (e não double) para que possa retornar null, caso esteja errado
     * @param valor
     * @return 
     * - <b>valor(double)</b> - Caso esteja correto<br/>
     * - <b>null</b> - caso esteja errado<br/>
     */
    public static Double validarCampoMoeda(String valor){
        try {
            return formatoMoeda.parse(valor).doubleValue();
        } catch (ParseException ex) {
            System.out.println("ex: " + ex.getMessage());
            ex.printStackTrace();
            return null;
        }
    }
    
    /**
     * Verifica se a dataAntiga é maior que a dataAtual. 
     * @param dataAntiga
     * @param dataAtual
     * @return 
     * - <b>true</b> - atual >= antiga<br/>
     * - <b>false</b> - atual < antiga <br/>
     */
    public static boolean validarDataMaior(Date dataAntiga){
        DateTime antiga = new DateTime(dataAntiga.getTime());
        
        if(antiga.isBeforeNow()) return true;
        return false;
    }
    
    /**
     * Método geral que verifica se um telefone é válido
     * @param telefone
     * @return 
     * true - se o telefone é válido <br/>
     * false - se o telefone não é válido <br/>
     */
    public static boolean validarTelefone(String telefone){
        try {
            telefone = mascaraTelefone.stringToValue(telefone).toString();
            telefone = telefone;
            return true;
        } catch (ParseException ex) {
            String erro = telefone;
            erro = erro.replaceAll("[^0-9]", "");//tudo que for diferente de número será removido
            
            //se o campo estiver vazio indica que o que estava no campo era apenas a máscara, que não é um erro.
            if(erro.isEmpty()){
                telefone = "";
                return true;
            } else {
                return false;
            }
        }
    }
    
    /**
     * Método geral que verifica se um telefone é válido
     * @param cep
     * @return 
     * true - se o CEP é válido <br/>
     * false - se o CEP não é válido <br/>
     */
    public static boolean validarCep(String cep){
        try {
            cep = mascaraCep.stringToValue(cep).toString();
            return true;
        } catch (ParseException ex) {
            String erro = cep;
            erro = erro.replaceAll("[^0-9]", "");//tudo que for diferente de número será removido
            
            //se o campo estiver vazio indica que o que estava no campo era apenas a máscara, que não é um erro.
            if(erro.isEmpty()){
                cep = "";
                return true;
            }else {
                JOptionPane.showMessageDialog(null, "CEP informado é inválido!");
                return false;
            }   
        }
    }
    
    /**
     * Valida o cpf verificando primeiramente se o valor digitado é valido. Caso sim, verifica se já existe no banco de dados
     * algum funcionário com esse cpf.
     * @param cpf
     * @param operacao
     * @param persisteFuncionario
     * @return 
     * true - se o CEP é válido <br/>
     * false - se o CEP não é válido <br/>
     */
    public static boolean validarCpf(String cpf, int operacao, PersisteFuncionario persisteFuncionario){
        try {            
            cpf = mascaraCpf.stringToValue(cpf).toString();

            if(operacao < 1){
                //verifica se já existe o funcionário cadastrado no banco de dados
                Funcionario aux = new Funcionario();
                aux.setCpf(cpf);
                aux = persisteFuncionario.retornarFuncionarioPeloCPF(aux);

                if(aux == null) return true;

                JOptionPane.showMessageDialog(null, "Funcionário já cadastrado no sistema com o CPF informado");
                return false;
            }
            return true;
            
        } catch (ParseException ex) {
            JOptionPane.showMessageDialog(null, "Campo CPF preenchido incorretamente.");
            ex.printStackTrace();
            return false;
        }
    }
    
    /**
     * Valida o cpf verificando primeiramente se o valor digitado é valido. Caso sim, verifica se já existe no banco de dados
     * algum funcionário com esse cpf.
     * @param cpf
     * @param operacao
     * @param persisteFuncionario
     * @return 
     * true - se o CEP é válido <br/>
     * false - se o CEP não é válido <br/>
     */
    public static boolean validarCpf(String cpf, int operacao, PersisteCliente persistePaciente){
        try {
            cpf = mascaraCpf.stringToValue(cpf).toString();
            
            if(operacao < 1){
                //verifica se já existe o funcionário cadastrado no banco de dados
                Cliente aux = new Cliente();
                aux.setCpf(cpf);
                aux = persistePaciente.retornarPacientePeloCPF(aux);

                if(aux == null) return true;

                JOptionPane.showMessageDialog(null, "Paciente já cadastrado no sistema");
                return false;
            }
            return true;
            
        } catch (ParseException ex) {
            JOptionPane.showMessageDialog(null, "Campo CPF preenchido incorretamente.");
            ex.printStackTrace();
            return false;
        }
    }
    
    /**
     * Verifica se o campo nome é válido. Ele será válido se não estiver vazio
     * @param nome
     * @return 
     */
    public static boolean validarNome(String nome){
        if(nome.isEmpty()){
            return false;
        }
        
        return true;
    }
    
    /**
     * Verifica se um campo é válido. Ele será válido se não estiver vazio
     * @param campoTexto
     * @return 
     */
    public static boolean validarCampoTexto(String campoTexto){
        if(campoTexto.isEmpty()){
            return false;
        }
        
        return true;
    }
    
    
    /**
     * Verifica se o número informado é válido. Será válido se não for vazio e conter somente números
     * @param numero
     * @return 
     */
    public static boolean validarNumero(String numero){
        if(numero.isEmpty() || Validacoes.validarCampoNumerico(numero)) {
            return true;
        }
        else {
            JOptionPane.showMessageDialog(null, "Campo número preenchido incorretamente!");
            return false;
        }
    }
    
    /**
     * Verifica se a data passada como parâmetro é maior que a atual
     * @param data
     * @return 
     */
    public static boolean validarData(Date data, boolean campoObrigatorio){
        if(data == null && !campoObrigatorio) return true;
        if(validarDataMaior(data))return true;
        return false;
    }
    
}